home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 002 / emacssrc.arc / ST520.C < prev    next >
C/C++ Source or Header  |  1987-02-15  |  21KB  |  1,030 lines
  1. /*
  2.  
  3. The routines in this file provide support for the Atari ST520 or 1040
  4. using VT52 emulation.  The I/O services are provided here as well.  It
  5. compiles into nothing if not a ST520 style device.
  6.  
  7. */
  8.  
  9. #define    termdef    1            /* don't define "term" external */
  10.  
  11. #include        <stdio.h>
  12. #include        "estruct.h"
  13. #include    "edef.h"
  14.  
  15. #if MEGAMAX
  16. overlay "st520"
  17. #endif
  18.  
  19. #if     ATARI & ST520 & MEGAMAX
  20. #include    <osbind.h>
  21. #include    <ctype.h>
  22.  
  23. #define LINEA_INIT 0xA000
  24. #define V_CEL_WR   -0x28
  25. #define V_CEL_MY   -0x2a
  26. #define V_CEL_HT   -0x2e
  27. #define V_FNT_AD   -0x16
  28. #define V_OFF_AD   -0x0a
  29. #define V_DISAB    -346
  30.  
  31. #define NROW    25                      /* Screen size.                 */
  32. #define NCOL    80                      /* Edit if you want to.         */
  33. #define    MARGIN    8            /* size of minimim margin and    */
  34. #define    SCRSIZ    64            /* scroll size for extended lines */
  35. #define    NPAUSE    25            /* # times thru update to pause */
  36. #define BIAS    0x20                    /* Origin 0 coordinate bias.    */
  37. #define ESC     0x1B                    /* ESC character.               */
  38. #define BEL     0x07                    /* ascii bell character         */
  39.  
  40. extern  int     ttopen();               /* Forward references.          */
  41. extern  int     ttgetc();
  42. extern  int     ttputc();
  43. extern  int     ttflush();
  44. extern  int     ttclose();
  45. extern  int     st520move();
  46. extern  int     st520eeol();
  47. extern  int     st520eeop();
  48. extern  int     st520beep();
  49. extern  int     st520open();
  50. extern    int    st520close();
  51. extern    int    st520rev();
  52. extern  int st520kopen();
  53. extern  int st520kclose();
  54. extern    int st520chgrez();
  55.  
  56. #if    COLOR
  57. extern    int    st520fcol();
  58. extern    int    st520bcol();
  59.  
  60. int        cfcolor = -1;        /* current fg (character) color */
  61. int        cbcolor = -1;        /* current bg color */
  62. int        oldpal[8];        /* pallette when emacs was invoked */
  63. int        newpal[8] = {        /* default emacs pallette */
  64.     0x000, 0x700, 0x070, 0x770, 0x007, 0x707, 0x077, 0x777};
  65. #endif
  66.  
  67. int STncolors = 0;        /* number of colors  */
  68. int STrez;            /* physical screen resolution */    
  69.  
  70. /*
  71.  * Dispatch table. All the
  72.  * hard fields just point into the
  73.  * terminal I/O code.
  74.  */
  75. TERM    term    = {
  76.         NROW-1,
  77.         NCOL,
  78.     MARGIN,
  79.     MARGIN,
  80.     SCRSIZ,
  81.     NPAUSE,
  82.         &st520open,
  83.         &st520close,
  84.     &st520kopen,
  85.     &st520kclose,
  86.         &ttgetc,
  87.         &ttputc,
  88.         &ttflush,
  89.         &st520move,
  90.         &st520eeol,
  91.         &st520eeop,
  92.         &st520beep,
  93.         &st520rev
  94. #if    MULTREZ
  95.     , &st520chgrez
  96. #endif
  97. #if    COLOR
  98.     , &st520fcol,
  99.     &st520bcol
  100. #endif
  101. };
  102.     struct KBDvecs {
  103.         int (*midivec) ();
  104.         int (*vkbderr) ();
  105.         int (*vmiderr) ();
  106.         int (*statvec) ();
  107.         int (*mousevec) ();
  108.         int (*clockvec) ();
  109.         int (*joyvec) ();
  110.         int (*midisys) ();
  111.         int (*ikbdsys) ();
  112.     };
  113.     struct Param {
  114.         char topmode;
  115.         char buttons;
  116.         char xparam;
  117.         char yparam;
  118.         int xmax,ymax;
  119.         int xinitial,yinitial;
  120.     };
  121.     struct KBDvecs *kbdvecs;
  122.     struct Param *paramp;
  123.     char kbdcmds[25];
  124.  
  125. st520move(row, col)
  126. {
  127.         ttputc(ESC);
  128.         ttputc('Y');
  129.         ttputc(row+BIAS);
  130.         ttputc(col+BIAS);
  131. }
  132.  
  133. st520eeol()
  134. {
  135.         ttputc(ESC);
  136.         ttputc('K');
  137. }
  138.  
  139. st520eeop()
  140. {
  141.  
  142. #if    COLOR
  143.         st520fcol(gfcolor);
  144.         st520bcol(gbcolor);
  145. #endif
  146.         ttputc(ESC);
  147.         ttputc('J');
  148. }
  149.  
  150. st520rev(status)    /* set the reverse video state */
  151.  
  152. int status;    /* TRUE = reverse video, FALSE = normal video */
  153.  
  154. {
  155.  
  156.     if(status) {
  157.         ttputc(ESC);
  158.         ttputc('p');
  159.     }
  160.     else {
  161.         ttputc(ESC);
  162.         ttputc('q');
  163.     }
  164. }
  165.  
  166. #if    COLOR
  167. st520fcol(color)
  168. int color;    
  169. {
  170.         if(color == cfcolor || !STncolors)
  171.             return;
  172.         else {
  173.  
  174.             ttputc(ESC);
  175.             ttputc('b');
  176.             ttputc(color & 0x0f);
  177.             cfcolor = color;
  178.         }
  179. }
  180.  
  181. st520bcol(color)
  182. int color;
  183. {
  184.         if(color == cbcolor || !STncolors)
  185.             return;
  186.         else {
  187.             ttputc(ESC);
  188.             ttputc('c');
  189.             ttputc(color & 0x0f);
  190.             cbcolor = color;
  191.         }
  192.  
  193. }
  194. #endif
  195.  
  196. st520beep()
  197. {
  198. #ifdef  BEL
  199.         ttputc(BEL);
  200.         ttflush();
  201. #endif
  202. }
  203.  
  204. st520open()
  205. {
  206.     int i,j,k;
  207.     long phys, log;    /* screen bases */
  208.     
  209. /* IMPORTANT: it is ABSOLUTELY necessary that the default resolution be the
  210.  *    largest possible so that display will allocate (malloc) the maximum
  211.  *    size for the VIDEO arrray
  212.  */
  213.     STrez = Getrez();
  214.     switch(STrez) {
  215.         case 0: /* low res 25x40 16 colors */
  216.             phys = Physbase();
  217.             log  = Logbase();
  218.             Setscreen(log, phys, 1);
  219.             STrez = 1;
  220.             /* fall thru to med res */
  221.  
  222.         case 1: /* med res 25x80 4 colors */
  223.             term.t_nrow = 25 - 1;
  224.             term.t_ncol  = 80;
  225.             grez = 1;
  226. #if    COLOR
  227.             STncolors = 4;
  228.             for(i=0;i<8;i++) {
  229.                 oldpal[i] = Setcolor(i,newpal[i]);
  230.             }
  231. #endif
  232.             break;
  233.         case 2: /* high res 25x80 no colors */
  234.             term.t_nrow  = 40 - 1;
  235.             term.t_ncol  = 80;
  236.             grez = 2;
  237.             make_8x10(); /* create a smaller font */
  238.             set_40();    /* and go to 40 line mode */
  239. #if    COLOR
  240.             STncolors = 0;
  241. #endif
  242.             break;
  243.     }
  244.  
  245.     revexist = TRUE;
  246.     eolexist = TRUE;
  247.     paramp = (struct Param *)malloc(sizeof(struct Param));
  248.     kbdvecs = (struct KBDvecs *)Kbdvbase();
  249.     paramp -> topmode = 0;
  250.     paramp -> buttons = 4;
  251.     paramp -> xparam = 8;
  252.     paramp -> yparam = 10;
  253.     paramp -> xmax = 79;
  254.     paramp -> ymax = 23;
  255.     paramp -> xinitial = 0;
  256.     paramp -> yinitial = 0;
  257.     Initmous(1,paramp,kbdvecs -> mousevec);
  258.  
  259.     i = 0;
  260.     kbdcmds[i++] = 0x0a;    /*set mouse keycode mode */
  261.     kbdcmds[i++] = 0x08;
  262.     kbdcmds[i++] = 0x0a;
  263.     Ikbdws(i-1,&kbdcmds[0]);
  264.     Cursconf(1,0);
  265.     Cursconf(3,0);
  266.     Cconout(27);Cconout('E');
  267.         ttopen();
  268. }
  269.  
  270. st520close()
  271.  
  272. {
  273.     int i,j,k;
  274.  
  275.     i = 0;
  276.     kbdcmds[i++] = 0x80;    /*reset mouse keycode mode */
  277.     kbdcmds[i++] = 0x01;
  278.     Ikbdws(i-1,&kbdcmds[0]);
  279.     if(grez == 2 && STrez == 2) /* b/w monitor in 40 row mode */
  280.         restore();
  281.  
  282. #if        COLOR
  283.     for(i=0;i<STncolors;i++)
  284.         Setcolor(i,oldpal[i]);
  285. #endif
  286.     Cconout(27);Cconout('E');
  287.     paramp -> buttons = 0;
  288.     Initmous(2,paramp,kbdvecs -> mousevec);
  289.     i = 0;
  290.     kbdcmds[i++] = 0x80;    /*reset the keyboard*/
  291.     kbdcmds[i++] = 0x01;
  292.     Ikbdws(i-1,&kbdcmds[0]);
  293.     Cursconf(1,0);
  294.     ttclose();
  295. }
  296. st520kopen()
  297. {
  298.  
  299. }
  300. st520kclose()
  301. {
  302.  
  303. }
  304.  
  305. st520chgrez(nurez)
  306. int nurez;
  307. {
  308.     int ierr, i, j ,k;
  309.     long phys, log;    /* screen bases */
  310.     char dum[80]; /* for debugging only */
  311.         
  312.     if(grez == nurez)
  313.         return(TRUE);
  314.         
  315.     if(STrez == 2) { /* b/w monitor-only allow hi | med rez */
  316.         switch(nurez) {
  317.             case 2: /* high res */
  318.                 term.t_nrow  = 40 - 1;
  319.                 term.t_ncol  = 80;
  320.                 make_8x10(); /* create a smaller font */
  321.                 set_40();    /* and go to 40 line mode */
  322.                 grez = 2;
  323.                 sgarbf = TRUE;
  324.                 onlywind(1,1);
  325.                 break;
  326.             case 1: /* med res */
  327.                 term.t_nrow  = 25 - 1;
  328.                 term.t_ncol  = 80;
  329.                 restore();
  330.                 grez = 1;
  331.                 sgarbf = TRUE;
  332.                 onlywind(1,1);
  333.                 break;
  334.             default:
  335.                 mlwrite("Invalid resolution");
  336.                 return(FALSE);
  337.                 break;
  338.         }
  339.     }
  340.     else { /* color monitor-only allow low | medium resolution */
  341.         phys = Physbase();
  342.         log  = Logbase();
  343.         switch(nurez) {
  344.             case 1:
  345.                 term.t_nrow  = 25 - 1;
  346.                 term.t_ncol  = 80;
  347.                 Setscreen(log, phys, 1);
  348.                 STncolors = 4;
  349.                 grez = 1;
  350.                 sgarbf = TRUE;
  351.                 onlywind(1,1);
  352.                 break;
  353.             case 0:
  354.                 term.t_nrow  = 25 - 1;
  355.                 term.t_ncol  = 40;
  356.                 Setscreen(log, phys, 0);
  357.                 STncolors = 8;
  358.                 grez = 0;
  359.                 sgarbf = TRUE;
  360.                 onlywind(1,1);
  361.                 break;
  362.             default:
  363.                 mlwrite("%Invalid resolution");
  364.                 return(FALSE);
  365.                 break;
  366.         }
  367.     }
  368. }            
  369.  
  370. STcurblink(onoff)
  371. int onoff;
  372. {
  373.     if(onoff)
  374.         Cursconf(2,0);
  375.     else
  376.         Cursconf(3,0);
  377. }
  378.  
  379.  
  380. char parm_save[28];
  381. long fnt_8x10[640];
  382.  
  383. make_8x10()
  384. {
  385.     int i,j,k;
  386.     long savea23[2];
  387.     
  388.     for(i=0;i<640;i++)
  389.         fnt_8x10[i] = 0;
  390.         
  391.     asm {
  392.     movem.l    A2-A3,savea23(A6)
  393.     
  394.     dc.w    LINEA_INIT        ;A1 -> array of font headers
  395.  
  396.     lea    parm_save(A4),A2    ;A2 -> parameters savearea
  397.     move.l    V_OFF_AD(A0),(A2)+
  398.     move.l    V_FNT_AD(A0),(A2)+
  399.     move.w    V_CEL_HT(A0),(A2)+
  400.     move.w    V_CEL_MY(A0),(A2)+
  401.     move.w    V_CEL_WR(A0),(A2)+
  402.  
  403.  
  404.     move.l    04(A1),A1        ; A1 -> 8x8 font header
  405.     move.l    76(A1),A2        ; A2 -> 8x8 font data
  406.     lea    fnt_8x10+0x100(A4),A3    ; A3 -> 2nd line of font buffer
  407.     move.w    #0x200-1,D0        ; D0 <- longword counter for font xfer
  408.  
  409. fnt_loop:
  410.  
  411.     move.l    (A2)+,(A3)+
  412.     dbf    D0,fnt_loop
  413.         
  414.     movem.l    savea23(A6),A2-A3
  415.     }
  416.     
  417. }
  418.  
  419. set_40()
  420. {
  421.     long    savea23[2];
  422.     
  423.     asm {
  424.     
  425. ;
  426. ;  use the 8x10 character set: 40 line mode
  427. ;
  428.  
  429.     movem.l    A2-A3,savea23(A6)
  430.     
  431.     dc.w    LINEA_INIT
  432.  
  433.     move.l    04(A1),A1        ; A1 -> 8x8 font header
  434.     move.l    72(A1),V_OFF_AD(A0)    ; v_off_ad <- 8x8  offset table addr
  435.     lea    fnt_8x10(A4),A2
  436.     move.l    A2,V_FNT_AD(A0)        ; v_fnt_ad <- 8x10 font data addr
  437.  
  438.     move.w    #10,V_CEL_HT(A0)    ; v_cel_ht <- 10   8x10 cell height
  439.     move.w    #39,V_CEL_MY(A0)    ; v_cel_my <- 39   maximum cell "Y"
  440.     move.w    #800,V_CEL_WR(A0)    ; v_cel_wr <- 800  offset to cell Y+1
  441.  
  442.     movem.l savea23,A2-A3
  443.     }
  444. }
  445.  
  446. set_20()
  447. {
  448.     long    savea23[2];
  449.  
  450.     asm {
  451.         
  452. ;
  453. ;  use the 8x10 character set: 20 line mode
  454. ;
  455.  
  456.     movem.l    A2-A3,savea23(A6)
  457.     
  458.     dc.w    LINEA_INIT        ; A0 -> line A variables
  459.  
  460.     move.l    04(A1),A1        ; A1 -> 8x8 font header
  461.     move.l    72(A1),V_OFF_AD(A0)    ; v_off_ad <- 8x8  offset table addr
  462.     lea    fnt_8x10(A4),A2
  463.     move.l    A2,V_FNT_AD(A0)        ; v_fnt_ad <- 8x10 font data addr
  464.  
  465.     move.w    #10,V_CEL_HT(A0)    ; v_cel_ht <- 10   8x10 cell height
  466.     move.w    #19,V_CEL_MY(A0)    ; v_cel_my <- 19   maximum cell "Y"
  467.     move.w    #1600,V_CEL_WR(A0)    ; v_cel_wr <- 800  offset to cell Y+1
  468.     
  469.     movem.l    savea23,A2-A3
  470.     }
  471. }
  472.  
  473.  
  474. restore()
  475. {
  476.     long savea23[2];
  477.     
  478.     asm {
  479.     
  480. ;  return what was saved in parameter save zone    
  481.  
  482.     movem.l    A2-A3,savea23(A6)
  483.  
  484.     dc.w    LINEA_INIT        ; a0 -> line A variables
  485.  
  486.     lea    parm_save(A4),A2    ; a2 -> parameter save area
  487.     move.l    (A2)+,V_OFF_AD(A0)
  488.     move.l    (A2)+,V_FNT_AD(A0)
  489.     move.w    (A2)+,V_CEL_HT(A0)
  490.     move.w    (A2)+,V_CEL_MY(A0)
  491.     move.w    (A2)+,V_CEL_WR(A0)
  492.     
  493.     movem.l    savea23(A6),A2-A3
  494.     }          
  495. }
  496. GetCurStat(onoff)
  497. int    onoff;
  498. {
  499.     long savea23[2];
  500.  
  501.     asm {
  502.     movem.l    A2-A3,savea23(A6)
  503.  
  504.     dc.w    LINEA_INIT        ; a0 -> line A variables
  505.     move.w    V_DISAB(A0),onoff(A6)    ; 0 = cursor visible
  506.     moveq    #0,D0
  507.     move.w    V_DISAB(A0),D0    
  508.     movem.l    savea23(A6),A2-A3
  509.     }          
  510. }
  511. #else
  512. #if    ATARI & ST520 & LATTICE
  513.  
  514. /*
  515.     These routines provide support for the ATARI 1040ST using
  516. the LATTICE compiler using the virtual VT52 Emulator
  517.  
  518. */
  519.  
  520. #define NROW    40                      /* Screen size.                 */
  521. #define NCOL    80                      /* Edit if you want to.         */
  522. #define    MARGIN    8            /* size of minimim margin and    */
  523. #define    SCRSIZ    64            /* scroll size for extended lines */
  524. #define    NPAUSE    300            /* # times thru update to pause */
  525. #define BIAS    0x20                    /* Origin 0 coordinate bias.    */
  526. #define ESC     0x1B                    /* ESC character.               */
  527. #define BEL     0x07                    /* ascii bell character         */
  528.  
  529. /****    ST Internals definitions        *****/
  530.  
  531. /*    BIOS calls */
  532.  
  533. #define    BCONSTAT    1    /* return input device status */
  534. #define    CONIN        2    /* read character from device */
  535. #define    BCONOUT        3    /* write character to device */
  536.  
  537. /*    XBIOS calls */
  538.  
  539. #define    INITMOUS    0    /* initialize the mouse */
  540. #define    GETREZ        4    /* get current resolution */
  541. #define    SETSCREEN    5    /* set screen resolution */
  542. #define    SETPALETTE    6    /* set the color pallette */
  543. #define    SETCOLOR    7    /* set or read a color */
  544. #define    CURSCONF    21    /* set cursor configuration */
  545. #define    IKBDWS        25    /* intelligent keyboard send command */
  546. #define    KBDVBASE    34    /* get keyboard table base */
  547.  
  548. /*    GEMDOG calls */
  549.  
  550. #define    EXEC        0x4b    /* Exec off a process */
  551.  
  552. #define    CON        2    /* CON: Keyboard and screen device */
  553.  
  554. /*    LINE A variables    */
  555.  
  556. #define LINEA_INIT 0xA000
  557. #define V_CEL_WR   -0x28
  558. #define V_CEL_MY   -0x2a
  559. #define V_CEL_HT   -0x2e
  560. #define V_FNT_AD   -0x16
  561. #define V_OFF_AD   -0x0a
  562. #define V_DISAB    -346
  563.  
  564. /*    Palette color definitions    */
  565.  
  566. #define    LOWPAL    "000700070770007707077777"
  567. #define    MEDPAL    "000700007777"
  568. #define    HIGHPAL    "000111"
  569.  
  570. /*    ST Global definitions        */
  571.  
  572. /* keyboard vector table */
  573. struct KVT {
  574.     long midivec;        /* midi input */
  575.     long vkbderr;        /* keyboard error */
  576.     long vmiderr;        /* MIDI error */
  577.     long statvec;        /* IKBD status */
  578.     int (*mousevec)();    /* mouse vector */
  579.     long clockvec;        /* clock vector */
  580.     long joyvec;        /* joystict vector */
  581. } *ktable;
  582.  
  583. int (*sysmint)();            /* system mouse interupt handler */
  584.  
  585. /* mouse parameter table */
  586. struct Param {
  587.     char topmode;
  588.     char buttons;
  589.     char xparam;
  590.     char yparam;
  591.     int xmax,ymax;
  592.     int xinitial,yinitial;
  593. } mparam;
  594.  
  595. int currez;            /* current screen resolution */
  596. char resname[][8] = {        /* screen resolution names */
  597.     "LOW", "MEDIUM", "HIGH", "DENSE"
  598. };
  599. short spalette[16];            /* original color palette settings */
  600. short palette[16];            /* current palette settings */
  601.  
  602. extern  int     ttopen();               /* Forward references.          */
  603. extern  int     ttgetc();
  604. extern  int     ttputc();
  605. extern  int     ttflush();
  606. extern  int     ttclose();
  607. extern  int     stmove();
  608. extern  int     steeol();
  609. extern  int     steeop();
  610. extern  int     stbeep();
  611. extern  int     stopen();
  612. extern    int    stclose();
  613. extern    int    stgetc();
  614. extern    int    stputc();
  615. extern    int    strev();
  616. extern    int    strez();
  617. extern    int    stkopen();
  618. extern    int    stkclose();
  619.  
  620. #if    COLOR
  621. extern    int    stfcol();
  622. extern    int    stbcol();
  623. #endif
  624.  
  625. /*
  626.  * Dispatch table. All the
  627.  * hard fields just point into the
  628.  * terminal I/O code.
  629.  */
  630. TERM    term    = {
  631.     NROW-1,
  632.         NROW-1,
  633.         NCOL,
  634.         NCOL,
  635.     MARGIN,
  636.     SCRSIZ,
  637.     NPAUSE,
  638.         &stopen,
  639.         &stclose,
  640.     &stkopen,
  641.     &stkclose,
  642.         &stgetc,
  643.     &stputc,
  644.         &ttflush,
  645.         &stmove,
  646.         &steeol,
  647.         &steeop,
  648.         &stbeep,
  649.         &strev,
  650.     &strez
  651. #if    COLOR
  652.     , &stfcol,
  653.     &stbcol
  654. #endif
  655. };
  656.  
  657. stmove(row, col)
  658. {
  659.         stputc(ESC);
  660.         stputc('Y');
  661.         stputc(row+BIAS);
  662.         stputc(col+BIAS);
  663. }
  664.  
  665. steeol()
  666. {
  667.         stputc(ESC);
  668.         stputc('K');
  669. }
  670.  
  671. steeop()
  672. {
  673. #if    COLOR
  674.     stfcol(gfcolor);
  675.     stbcol(gbcolor);
  676. #endif
  677.         stputc(ESC);
  678.         stputc('J');
  679. }
  680.  
  681. strev(status)    /* set the reverse video state */
  682.  
  683. int status;    /* TRUE = reverse video, FALSE = normal video */
  684.  
  685. {
  686.     if (currez > 1) {
  687.         stputc(ESC);
  688.         stputc(status ? 'p' : 'q');
  689.     }
  690. }
  691.  
  692. #if    COLOR
  693. mapcol(clr)    /* medium rez color translation */
  694.  
  695. int clr;    /* emacs color number to translate */
  696.  
  697. {
  698.     static int mctable[] = {0, 1, 2, 3, 2, 1, 2, 3};
  699.  
  700.     if (currez != 1)
  701.         return(clr);
  702.     else
  703.         return(mctable[clr]);
  704. }
  705.  
  706. stfcol(color)    /* set the forground color */
  707.  
  708. int color;    /* color to set forground to */
  709.  
  710. {
  711.     if (currez < 2) {
  712.         stputc(ESC);
  713.         stputc('b');
  714.         stputc(mapcol(color));
  715.     }
  716. }
  717.  
  718. stbcol(color)    /* set the background color */
  719.  
  720. int color;    /* color to set background to */
  721.  
  722. {
  723.     if (currez < 2) {
  724.         stputc(ESC);
  725.         stputc('c');
  726.         stputc(mapcol(color));
  727.     }
  728. }
  729. #endif
  730.  
  731. stbeep()
  732. {
  733.         stputc(BEL);
  734.         ttflush();
  735. }
  736.  
  737. domouse()    /* mouse interupt handler */
  738.  
  739. {
  740.     return((*sysmint)());
  741. }
  742.  
  743. stkopen()    /* open the keyboard (and mouse) */
  744.  
  745. {
  746.     /* grab the keyboard vector table */
  747.     ktable = (struct KVT *)xbios(KBDVBASE);
  748.     sysmint = ktable->mousevec;    /* save mouse vector */
  749.  
  750.     /* initialize the mouse */
  751.     mparam.topmode = 0;
  752.     mparam.buttons = 4;
  753.     mparam.xparam = 8;
  754.     mparam.yparam = 10;
  755.     mparam.xmax = 79;
  756.     mparam.ymax = 23;
  757.     mparam.xinitial = 0;
  758.     mparam.yinitial = 0;
  759.     xbios(INITMOUS, 4, &mparam, &domouse);
  760. }
  761.  
  762. stopen()    /* open the screen */
  763.  
  764. {
  765.     int i;
  766.  
  767.         ttopen();
  768.     eolexist = TRUE;
  769.  
  770.     /* switch to a steady cursor */
  771.     xbios(CURSCONF, 3);
  772.  
  773.     /* save the current color palette */
  774.     for (i=0; i<16; i++)
  775.         spalette[i] = xbios(SETCOLOR, i, -1);
  776.  
  777.     /* and find the current resolution */
  778.     currez = xbios(GETREZ);
  779.     strcpy(sres, resname[currez]);
  780.  
  781.     /* set up the screen size and palette */
  782.     switch (currez) {
  783.         case 0:    term.t_mrow = 25 - 1;
  784.             term.t_nrow = 25 - 1;
  785.             term.t_ncol = 40 - 1;
  786.             strcpy(palstr, LOWPAL);
  787.             break;
  788.  
  789.         case 1: term.t_mrow = 25 - 1;
  790.             term.t_nrow = 25 - 1;
  791.             strcpy(palstr, MEDPAL);
  792.             break;
  793.  
  794.         case 2: term.t_mrow = 40 - 1;
  795.             term.t_nrow = 25 - 1;
  796.             strcpy(palstr, HIGHPAL);
  797.     }
  798.  
  799.     /* and set up the default palette */
  800.     spal(palstr);
  801.  
  802.     stputc(ESC);    /* automatic overflow off */
  803.     stputc('w');
  804.     stputc(ESC);    /* turn cursor on */
  805.     stputc('e');
  806. }
  807.  
  808. stkclose()    /* close the keyboard (and mouse) */
  809.  
  810. {
  811.     static char resetcmd[] = {0x80, 0x01};    /* keyboard reset command */
  812.  
  813.     /* restore the mouse interupt routines */
  814.     xbios(INITMOUS, 2, &mparam, (long)sysmint);
  815.  
  816.     /* and reset the keyboard controller */
  817.     xbios(IKBDWS, 1, &resetcmd[0]);
  818. }
  819.  
  820. stclose()
  821.  
  822. {
  823.     stputc(ESC);    /* auto overflow on */
  824.     stputc('v');
  825.  
  826.     /* switch to a flashing cursor */
  827.     xbios(CURSCONF, 2);
  828.  
  829.     /* restore the original palette settings */
  830.     xbios(SETPALETTE, spalette);
  831.  
  832.     ttclose();
  833. }
  834.  
  835. /*     spal(pstr):    reset the current palette according to a
  836.             "palette string" of the form
  837.  
  838.     000111222333444555666777
  839.  
  840.     which contains the octal values for the palette registers
  841. */
  842.  
  843. spal(pstr)
  844.  
  845. char *pstr;    /* palette string */
  846.  
  847. {
  848.     int pal;    /* current palette position */
  849.     int clr;    /* current color value */
  850.     int i;
  851.  
  852.     for (pal = 0; pal < 16; pal++) {
  853.         if (*pstr== 0)
  854.             break;
  855.  
  856.         /* parse off a color */
  857.         clr = 0;
  858.         for (i = 0; i < 3; i++)
  859.             if (*pstr)
  860.                 clr = clr * 16 + (*pstr++ - '0');
  861.         palette[pal] = clr;
  862.     };
  863.  
  864.     /* and now set it */
  865.     xbios(SETPALETTE, palette);
  866. }
  867.  
  868. stgetc()    /* get a char from the keyboard */
  869.  
  870. {
  871.     int rval;        /* return value from BIOS call */
  872.     static int funkey = 0;    /* held fuction key scan code */
  873.  
  874.     /* if there is a pending function key, return it */
  875.     if (funkey) {
  876.         rval = funkey;
  877.         funkey = 0;
  878.     } else {
  879.         /* waiting... flash the cursor */
  880.         xbios(CURSCONF, 2);
  881.  
  882.         /* get the character */
  883.         rval = bios(CONIN, CON);
  884.         if ((rval & 255) == 0) {
  885.             funkey = (rval >> 16) & 255;
  886.             rval = 0;
  887.         }
  888.  
  889.         /* and switch to a steady cursor */
  890.         xbios(CURSCONF, 3);
  891.     }
  892.  
  893.     return(rval & 255);
  894. }
  895.  
  896. stputc(c)    /* output char c to the screen */
  897.  
  898. char c;        /* character to print out */
  899.  
  900. {
  901.     bios(BCONOUT, CON, c);
  902. }
  903.  
  904. strez(newrez)    /* change screen resolution */
  905.  
  906. char *newrez;    /* requested resolution */
  907.  
  908. {
  909.     int nrez;    /* requested new resolution */
  910.  
  911.     /* first, decode the resolution name */
  912.     for (nrez = 0; nrez < 4; nrez++)
  913.         if (strcmp(newrez, resname[nrez]) == 0)
  914.             break;
  915.     if (nrez == 4) {
  916.         mlwrite("%%No such resolution");
  917.         return(FALSE);
  918.     }
  919.  
  920.     /* next, make sure this resolution is legal for this monitor */
  921.     if ((currez < 2 && nrez > 1) || (currez > 1 && nrez < 2)) {
  922.         mlwrite("%%Resolution illegal for this monitor");
  923.         return(FALSE);
  924.     }
  925.  
  926.     /* eliminate non-changes */
  927.     if (currez == nrez)
  928.         return(TRUE);
  929.  
  930.     /* finally, make the change */
  931.     switch (nrez) {
  932.         case 0:    /* low resolution - 16 colors */
  933.             newwidth(TRUE, 40);
  934.             strcpy(palstr, LOWPAL);
  935.             xbios(SETSCREEN, -1, -1, 0);
  936.             break;
  937.  
  938.         case 1:    /* medium resolution - 4 colors */
  939.             newwidth(TRUE, 80);
  940.             strcpy(palstr, MEDPAL);
  941.             xbios(SETSCREEN, -1, -1, 1);
  942.             break;
  943.  
  944.         case 2:    /* High resolution - 2 colors - 25 lines */
  945.             newsize(TRUE, 25);
  946.             strcpy(palstr, HIGHPAL);
  947.             /* change char set back to normal */
  948.             break;
  949.  
  950.         case 3:    /* Dense resolution - 2 colors - 40 lines */
  951.             /* newsize(TRUE, 40); */
  952.             strcpy(palstr, HIGHPAL);
  953.             /*change char set size */
  954.             break;
  955.     }
  956.  
  957.     /* and set up the default palette */
  958.     spal(palstr);
  959.     currez = nrez;
  960.     strcpy(sres, resname[currez]);
  961.  
  962.     stputc(ESC);    /* automatic overflow off */
  963.     stputc('w');
  964.     stputc(ESC);    /* turn cursor on */
  965.     stputc('e');
  966.  
  967.     return(TRUE);
  968. }
  969.  
  970. system(cmd)    /* call the system to execute a new program */
  971.  
  972. char *cmd;    /* command to execute */
  973.  
  974. {
  975.     char *pptr;            /* pointer into program name */
  976.     char pname[NSTRING];        /* name of program to execute */
  977.     char tail[NSTRING];        /* command tail */
  978.  
  979.     /* scan off program name.... */
  980.     pptr = pname;
  981.     while (*cmd && (*cmd != ' ' && *cmd != '\t'))
  982.         *pptr++ = *cmd++;
  983.     *pptr = 0;
  984.  
  985.     /* create program name length/string */
  986.     tail[0] = strlen(cmd);
  987.     strcpy(&tail[1], cmd);
  988.  
  989.     /* go do it! */
  990.     return(gemdos(        EXEC,
  991.                 0,
  992.                 (char *)pname,
  993.                 (char *)tail,
  994.                 (char *)NULL));
  995. }
  996.  
  997. #if    TYPEAH
  998. typahead()
  999.  
  1000. {
  1001.     int rval;    /* return value from BIOS call */
  1002.  
  1003.     /* get the status of the console */
  1004.     rval = bios(BCONSTAT, CON);
  1005.  
  1006.     /* end return the results */
  1007.     if (rval == 0)
  1008.         return(FALSE);
  1009.     else
  1010.         return(TRUE);
  1011. }
  1012. #endif
  1013.  
  1014. #if    FLABEL
  1015. fnclabel(f, n)        /* label a function key */
  1016.  
  1017. int f,n;    /* default flag, numeric argument [unused] */
  1018.  
  1019. {
  1020.     /* on machines with no function keys...don't bother */
  1021.     return(TRUE);
  1022. }
  1023. #endif
  1024. #else
  1025. sthello()
  1026. {
  1027. }
  1028. #endif
  1029. #endif
  1030.